home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgramD2.iso / Borland / Borland C++ V5.02 / SPLASH.PAK / SPLASHX.CPP < prev    next >
C/C++ Source or Header  |  1997-05-06  |  5KB  |  216 lines
  1. //----------------------------------------------------------------------------
  2. // ObjectWindows
  3. // (C) Copyright 1995 by Borland International, All Rights Reserved
  4. //
  5. // Example to demonstrate TSplashWindow capabilities.
  6. //----------------------------------------------------------------------------
  7. #include <owl/pch.h>
  8. #include <owl/applicat.h>
  9. #include <owl/dialog.h>
  10. #include <owl/static.h>
  11. #include <owl/gauge.h>
  12. #include <owl/gdiobjec.h>
  13. #include <owl/splashwi.h>
  14. #include <stdio.h>
  15.  
  16. const uint WUM_START = WM_USER + 0x875;
  17.  
  18. TSplashWindow* Splash = 0;
  19.  
  20.  
  21. //
  22. // class TClientWindow
  23. // ~~~~~ ~~~~~~~~~~~~~
  24. class TClientWindow : public TWindow {
  25.   public:
  26.     TClientWindow(TWindow* parent= 0);
  27.     int32 WumStart(TParam1, TParam2);
  28.  
  29.   protected:
  30.     void SetupWindow();
  31.     int LoadPercentDone;
  32.  
  33.   DECLARE_RESPONSE_TABLE(TClientWindow);
  34. };
  35.  
  36.  
  37. DEFINE_RESPONSE_TABLE1(TClientWindow, TWindow)
  38.   EV_MESSAGE(WUM_START, WumStart),
  39. END_RESPONSE_TABLE;
  40.  
  41.  
  42. //
  43. //
  44. //
  45. TClientWindow::TClientWindow(TWindow* parent)
  46. :
  47.   TWindow(parent),
  48.   LoadPercentDone(0)
  49. {
  50.   Attr.Style |= (WS_CLIPSIBLINGS | WS_CLIPCHILDREN);
  51.  
  52.   // a theoretical 10-step loading process
  53.   //
  54.   LoadPercentDone = 10;
  55.   for (int i = 1; i <= 3; i++, LoadPercentDone += 10) {
  56.     // update the splash dialog for each step
  57.     //
  58.     char buffer[80];
  59.     sprintf(buffer, "Constructor step %d", i);
  60.     ::Splash->SetText(buffer);
  61.     ::Splash->SetPercentDone(LoadPercentDone);
  62.  
  63.     // application-specific startup initialization
  64.     //
  65.     switch (i) {
  66.       case 1: {
  67.         // maybe load first DLL
  68.         //
  69.         break;
  70.       } // case 1
  71.  
  72.       // other cases, etc.
  73.       //
  74.     }
  75.  
  76.     // a delay only for this demo only
  77.     //
  78.     uint32 start = GetTickCount();
  79.     while (GetTickCount() - start < 500)
  80.       ;
  81.   }
  82.  
  83. }
  84.  
  85.  
  86. //
  87. // Called before main window is displayed.
  88. //
  89. void
  90. TClientWindow::SetupWindow()
  91. {
  92.   TWindow::SetupWindow();
  93.  
  94.   // this initialization stuff requires a valid HWND
  95.   //
  96.   for (int i = 1; i <= 3; i++, LoadPercentDone += 10) {
  97.     // update the splash dialog for each step
  98.     //
  99.     char buffer[80];
  100.     sprintf(buffer, "SetupWindow step %d", i);
  101.     ::Splash->SetText(buffer);
  102.     ::Splash->SetPercentDone(LoadPercentDone);
  103.  
  104.     // application-specific startup initialization
  105.     //
  106.     switch (i) {
  107.       case 1: {
  108.         // maybe create new controls on the fly
  109.         // or initialize child controls
  110.         //
  111.         break;
  112.       } // case 1
  113.  
  114.       // other cases, etc.
  115.       //
  116.     }
  117.  
  118.     // a delay only for this demo only
  119.     //
  120.     uint32 start = GetTickCount();
  121.     while (GetTickCount() - start < 500)
  122.       ;
  123.   }
  124.  
  125.   // Ensure main window's painting routine is finished before continuing.
  126.   // This will appear that the main window comes up behind the splash.
  127.   PostMessage(WUM_START);
  128.   Parent->SetCaption("Hello World!");
  129. }
  130.  
  131.  
  132. //
  133. // Ensure main window's painting routine is finished before continuing.
  134. //
  135. int32
  136. TClientWindow::WumStart(TParam1, TParam2)
  137. {
  138.   // This initialization stuff guaranteed after the window is painted
  139.   //
  140.   for (int i = 1; i <= 4; i++, LoadPercentDone += 10) {
  141.     // Update the splash dialog for each step
  142.     //
  143.     char buffer[80];
  144.     sprintf(buffer, "WumStart step %d", i);
  145.     ::Splash->SetText(buffer);
  146.     ::Splash->SetPercentDone(LoadPercentDone);
  147.  
  148.     // Application-specific startup initialization
  149.     //
  150.     switch (i) {
  151.       case 1: {
  152.         // Other initialization
  153.         //
  154.         break;
  155.       } // case 1
  156.  
  157.       // Other cases, etc.
  158.       //
  159.     }
  160.  
  161.     // A delay only for this demo only
  162.     //
  163.     uint32 start = GetTickCount();
  164.     while (GetTickCount() - start < 500)
  165.       ;
  166.   }
  167.  
  168.   // Uncomment the next two lines to force splash to close
  169.   //
  170.  
  171.   // delete ::Splash;
  172.   // ::Splash = 0;
  173.  
  174.   return 0;
  175. }
  176.  
  177. //----------------------------------------------------------------------------
  178.  
  179. //
  180. // class TSampleApp
  181. // ~~~~~ ~~~~~~~~~~
  182. class TSampleApp : public TApplication {
  183.   public:
  184.     void InitMainWindow();
  185. };
  186.  
  187. //
  188. // Create the main window.
  189. //
  190. void
  191. TSampleApp::InitMainWindow()
  192. {
  193.   // Construct & create the splash screen
  194.   //
  195.   int style = TSplashWindow::MakeStatic |
  196.               TSplashWindow::MakeGauge |
  197.               TSplashWindow::CaptureMouse |
  198.               TSplashWindow::ShrinkToFit;
  199.   int timeOut = 3000;
  200.  
  201.   ::Splash = new TSplashWindow(*new TDib("splslogo.bmp"), 400, 300,
  202.     style, timeOut, "", this);
  203.   ::Splash->Create();
  204.  
  205.   // Construct the main window
  206.   //
  207.   SetMainWindow(new TFrameWindow(0, 0, new TClientWindow()));
  208. }
  209.  
  210.  
  211. int
  212. OwlMain(int /*argc*/, char* /*argv*/[])
  213. {
  214.   return TSampleApp().Run();
  215. }
  216.